home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / apps / 41 / proffsrc / pxxparse.c < prev    next >
C/C++ Source or Header  |  1986-07-17  |  10KB  |  514 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include "proff.h"
  4. #include "debug.h"
  5. #include "lextab.h"
  6.  
  7. #define brk brrk
  8.  
  9. #define RUNOFF    1         /* recognise RUNOFF commands */
  10.  
  11. char literal = NO;        /* literal flag             */
  12.  
  13. /*
  14.  * command - perform formatting command
  15.  *
  16.  */
  17. command(buf)
  18. char buf[];
  19. {
  20.     char token[MAXTOK], xtoken[MAXTOK], variable[MAXTOK], *defn;
  21.     char special[MAXTOK];
  22.     int argtyp, ct, at, spval, i, flags;
  23.     register int val, n, rest;
  24.     char onflag = FALSE; 
  25.     char offlag = FALSE;
  26.     struct lexlist *xp;
  27.  
  28.     dovar(tbuf1,buf);    /* use scratch buffer to expand variables */
  29.     strcpy(buf,tbuf1);
  30.  
  31.     i = 1;
  32.     n = getwrd(buf, &i, token);    /* get the command token */
  33.     rest = i;            /* remaining string */
  34.     ct = comtype(token, n, &defn, &flags);
  35.     if (ct == UNKNOWN)
  36.         return;
  37.     if (literal && ct != ELT) {    /* ignore while literal  */
  38.         put(buf);
  39.         return;
  40.     }
  41.  
  42. #ifdef DOUBLEWORD
  43.     if (flags == 2) {    /* check for 2-word command */
  44.         n = getwrd(buf, &i, xtoken);
  45.         if (n == 0) {
  46.             fprintf(stderr,"%c%s what ?\n", cchar, token);
  47.             return;
  48.         }
  49.         if ((at = comtype(xtoken, n, &defn, &flags)) == UNKNOWN) {
  50.             fprintf(stderr,"%c%s %s unknown.\n", cchar,
  51.             token,
  52.             xtoken);
  53.             return;
  54.         }
  55.         else
  56.             ct += at;
  57.     }
  58. #endif
  59.  
  60.     doesc(buf, variable, MAXLINE);    /* expand escapes */
  61.     n = getarg(buf, &i, xtoken);    /* first parameter*/
  62.     argtyp = '\n';    /* defaulted ** cludge ** */
  63.     val = 0;
  64.     if (n > 0) {
  65.         if (*xtoken == '+' || *xtoken == '-') {
  66.             argtyp = *xtoken;
  67.             val = atoi(xtoken+1);
  68.         }
  69.         else if (isdigit(*xtoken)) {
  70.             argtyp = 0;
  71.             val = atoi(xtoken);
  72.         }
  73.         else {
  74.             /* check some common flags */
  75.             if (strcmp("on",xtoken) == 0)
  76.                 onflag = TRUE;
  77.             else if (strcmp("off",xtoken) == 0)
  78.                 offlag = TRUE;
  79.         }
  80.     }
  81.  
  82.     switch(ct) {
  83.  
  84.     case MACRO:
  85.         eval(buf, defn);
  86.         break;
  87.     case FI:
  88.         brk();
  89.         fill = YES;
  90.         break;
  91.     case NF:
  92.         brk();
  93.         fill = NO;
  94.         break;
  95.     case BR:
  96.         brk();
  97.         break;
  98.     case LS:
  99.         set(&lsval, val, argtyp, 1, 1, HUGE);
  100.         break;
  101.     case CE:
  102.         brk();
  103.         if (onflag)
  104.             CEon = TRUE;
  105.         else if (offlag) {
  106.             CEon = FALSE;
  107.             ceval = 0;        /* reset */
  108.         }
  109.         else
  110.             set(&ceval, val, argtyp, 1, 0, HUGE);
  111.         break;
  112.     case UL:
  113.         if (onflag) {
  114.             ULon = TRUE;
  115.             break;
  116.         }
  117.         else if (offlag) {
  118.             ULon = FALSE;
  119.              ulval = 0;        /* reset */
  120.             break;
  121.         }
  122.         else 
  123.             set(&ulval, val, argtyp, 0, 1, HUGE);
  124.  
  125.         if (!isdigit(*xtoken)) {
  126.             if (strcmp("all",xtoken) == 0) {
  127.                     ulblnk = '_';
  128.                     ulval = 0;
  129.             }
  130.             else if (strcmp("words",xtoken) == 0) {
  131.                 ulblnk = ' ';
  132.                 ulval = 0;
  133.             }
  134.         }
  135.         break;
  136.     case BD:
  137.         if (bolding == YES) {
  138.             if (onflag)
  139.                 BDon = TRUE;
  140.             else if (offlag) {
  141.                 BDon = FALSE;
  142.                 boval = 0;    /* reset */
  143.             }
  144.             else
  145.                 set(&boval, val, argtyp, 0, 1, HUGE);
  146.         }
  147.         break;
  148.     case HE:
  149.         gettl(buf, ehead, ehlim);
  150.         gettl(buf, ohead, ohlim);
  151.         break;
  152.     case FO:
  153.         gettl(buf, efoot, eflim);
  154.         gettl(buf, ofoot, oflim);
  155.         break;
  156.     case BP:
  157.         if (paging == NO)
  158.             break;
  159.         brk();
  160.         if (lineno > 0)
  161.             space(HUGE);
  162.         set(&curpag, val, argtyp, curpag+1, -HUGE, HUGE);
  163.         newpag = curpag;
  164.         break;
  165.     case SP:
  166.         set(&spval, val, argtyp, 1, 0, HUGE);
  167.         space(spval);
  168.         break;
  169.     case IN:
  170.         brk();
  171.         set(&inval, val, argtyp, 0, 0, rmval-1);
  172.         tival = inval;
  173.         break;
  174.     case RM:
  175.         set(&rmval, val, argtyp, PAGEWIDTH, tival+1, HUGE);
  176.         break;
  177.     case TI:
  178.         brk();
  179.         set(&tival, val, argtyp, 0, 0, rmval);
  180.         break;
  181.     case LEX:    /****/
  182.         if ((xp = remove(xtoken,lextab)) != NULL) {
  183.             if (getwrd(buf, &i, variable) != 0)
  184.                 lexinstal(variable,xp->val,xp->flag,lextab);
  185.         }
  186.         else 
  187.             fprintf(stderr,"%s undefined.\n",xtoken);
  188.         break;
  189.     case PN:    /****/
  190.         if (strcmp(xtoken,"roman") == 0)
  191.             roman = TRUE;
  192.         else if (strcmp(xtoken,"arabic") == 0)
  193.             roman = FALSE;
  194.         else
  195.             fprintf(stderr,"%c%s does not have %s option.\n",
  196.             cchar,token,xtoken);
  197.         break;
  198.     case IG:    /****/
  199.         break;
  200.     case SET:    /****/
  201.         if (n > 0) {
  202.             if (isdigit(*xtoken)) {
  203.                 fprintf(stderr,"illegal variable name %s\n",
  204.                 xtoken);
  205.                 break;
  206.             }
  207.             *variable = '\0';
  208.             n = getarg(buf, &i, variable);
  209.             if (n <= 0) {
  210.                 fprintf(stderr,"%s: ", xtoken);
  211.                 gets(variable);
  212.  
  213.             }
  214.             if (*variable != '\0')
  215.                 install(xtoken, variable, gentab);
  216.         }
  217.         else
  218.             fprintf(stderr,"%c%s needs a variable name.\n",
  219.             cchar, token);
  220.         break;
  221.     case GET:    /****/
  222.         if (n > 0) {
  223.             if (isdigit(*xtoken)) {
  224.                 fprintf(stderr,"illegal variable name %s\n",
  225.                 xtoken);
  226.                 break;
  227.             }
  228.             *variable = '\0';
  229.             n = getarg(buf, &i, tbuf3); /* using temp buf3 */
  230.             if (n > 0) {
  231.                 fprintf(stderr,"%s", tbuf3);
  232.                 gets(variable);
  233.  
  234.             }
  235.             if (*variable != '\0')
  236.                 install(xtoken,variable, gentab);
  237.         }
  238.         else
  239.             fprintf(stderr,"%c%s needs a variable name.\n",
  240.             cchar, token);
  241.         break;
  242.     case CL:    /****/
  243.         if (argtyp == '\n') {
  244.             clast->level = 0;
  245.             clast->str = NULL;
  246.         }
  247.         else {
  248.             skipbl(buf,&i);
  249.             if (*(buf+i) == '\0')
  250.                 break;        /* no contents line here ! */
  251.             clast->level = val * 3; /* level * indent        */
  252.             n = i;
  253.             while(*(buf+n) != '\n')
  254.                 n++;
  255.             *(buf+n) = '\0';    /* destroy CR with a null  */
  256.             clast->str = strsave(buf+i);
  257.             clast->page = curpag;
  258.         }
  259.         clast->nextc = (struct clist *) malloc(sizeof(struct clist));
  260.         p_memoryus += sizeof(struct clist);
  261.         clast = clast->nextc;
  262.         clast->nextc = NULL;
  263.         break;
  264.     case PC:    /****/
  265.         brk();
  266.         clast = chead;
  267.         while(clast->nextc != NULL) {
  268.             if (clast->str == NULL)
  269.                 put("\n");
  270.             else {
  271.                 tival = (int) clast->level + inval;
  272.                 i = rmval - tival;
  273.                 docline(variable, i, clast->str, clast->page);
  274.                 put(variable);
  275.             }
  276.             clast = clast->nextc;
  277.         }
  278.         break;
  279.     case DBO:    /****/
  280.         bolding = NO;
  281.         break;
  282.     case EBO:    /****/
  283.         bolding = YES;
  284.         break;
  285.     case AP:    /****/
  286.         autopar = YES;
  287.         break;
  288.     case NAP:    /****/
  289.         autopar = NO;
  290.         break;
  291.     case SAV:    /****/
  292.         brk();
  293.         save();
  294.         break;
  295.     case RST:    /****/
  296.         brk();
  297.         restore();
  298.         break;
  299.     case NPA:    /****/
  300.         paging = NO;
  301.         savpl = plval;
  302.         plval = HUGE;
  303.         bottom = plval - m3val - m4val;
  304.         break;
  305.     case PGI:    /****/
  306.         bottom = lineno - 1;    /* force end-of-page */
  307.         brk();
  308.         plval = savpl;
  309.         break;
  310.     case LTR:    /****/
  311.         brk();
  312.         if (save()) {
  313.             inval = 0;
  314.             rmval = 132;
  315.             autopar = NO;
  316.             lsval = 0;
  317.             fill = NO;
  318.             literal = YES;
  319.         }
  320.         break;
  321.     case ELT:    /****/
  322.         restore();
  323.         literal = NO;
  324.         break;
  325.     case WR:    /****/
  326.         brk();
  327.         getpstr(buf+rest,special);
  328.         defn = special;
  329.         while(*defn)
  330.             putchar(*defn++);
  331.         break;
  332.     case PL:
  333.         if (paging == NO)
  334.             break;
  335.         set(&plval, val, argtyp, PAGELEN,
  336.         m1val + m2val + m3val + m4val + 1, HUGE);
  337.         bottom = plval - m3val - m4val;
  338.         break;
  339.     case PO:
  340.         set(&offset, val, argtyp, 0, 0, rmval - 1);
  341.         break;
  342.     case M1:
  343.         set(&m1val, val, argtyp, 3, 0,
  344.         plval - m2val - m3val - m4val - 1);
  345.         break;
  346.     case M2:
  347.         set(&m2val, val, argtyp, 2, 0,
  348.         plval - m1val - m3val - m4val - 1);
  349.         break;
  350.     case M3:
  351.         set(&m3val, val, argtyp, 2, 0,
  352.         plval - m1val - m2val - m4val - 1);
  353.         bottom = plval - m3val - m4val;
  354.         break;
  355.     case M4:
  356.         set(&m4val, val, argtyp, 3, 0,
  357.         plval - m1val - m2val - m3val - 1);
  358.         bottom = plval - m3val - m4val;
  359.         break;
  360.     case EH:
  361.         gettl(buf, ehead, ehlim);
  362.         break;
  363.     case OH:
  364.         gettl(buf, ohead, ohlim);
  365.         break;
  366.     case EF:
  367.         gettl(buf, efoot, eflim);
  368.         break;
  369.     case OF:
  370.         gettl(buf, ofoot, oflim);
  371.         break;
  372.     case CC:
  373.         cchar = *xtoken;
  374.         if (cchar == '\0' || cchar == '\n')
  375.             cchar = '.';
  376.         if ((lineno + val) > bottom && lineno <= bottom) {
  377.             space(val);
  378.             lineno = 0;
  379.         }
  380.         break;
  381.     case EC:
  382.         genesc = *xtoken;
  383.         if (genesc == '\0' || genesc == '\n')
  384.             genesc = '_';
  385.         break;
  386.     case NE:
  387.         if ((lineno + val) > bottom && lineno <= bottom) {
  388.             space(val);
  389.             lineno = 0;
  390.         }
  391.         break;
  392.     case BS:
  393.         set(&bsval, val, argtyp, 1, 0, HUGE);
  394.         break;
  395.     case JU:
  396.         rjust = YES;
  397.         break;
  398.     case NJ:
  399.         rjust = NO;
  400.         break;
  401.     case SO:
  402.         if (n <= 0)
  403.             return;
  404.         if (level + 1 == NFILES)
  405.             error("? SO commands nested too deeply.");
  406.         if ((infile[level + 1] = fopen(xtoken, "r")) != NULL) {
  407.             level++;
  408.             if (verbose == YES)
  409. #ifdef rainbow
  410.                 fprintf(stderr,"source \033[7m%s\033[0m\n",
  411.                     xtoken);
  412. #else
  413.                 fprintf(stderr,"source %s\n",xtoken);
  414. #endif
  415.         }
  416.         else
  417.             fprintf(stderr,"%s: cannot open.\n",xtoken);
  418.         break;
  419.     case OU:    /*****/
  420.         /* skip for now. */
  421.         break;
  422.  
  423.     case OE:    /*****/
  424.         /* skip for now. */
  425.         break;
  426.  
  427.     case CU:
  428.         ulblnk = '_';
  429.         set(&ulval, val, argtyp, 0, 1, HUGE);
  430.         break;
  431.     case DE:
  432.  
  433. #ifdef DEBUG
  434. printf("Command++: calling dodef Fp %ld\n",infile[level]);
  435. #endif
  436.         dodef(buf, infile[level]);
  437.         break;
  438.     case NR:
  439.         if (n <= 0)
  440.             return;
  441.         if (*xtoken < 'a' || *xtoken > 'z')
  442.             error("invalid number register [%c].",*xtoken);
  443.  
  444.         val = getval(buf, &i, &argtyp);
  445.         set(&nr[xtoken[0] - 'a'], val, argtyp, 0, -HUGE, HUGE);
  446.         break;
  447.     case ST:
  448.         if (argtyp == '-')
  449.             spval = plval;
  450.         else
  451.             spval = 0;
  452.         set(&spval, val, argtyp, 0, 1, bottom);
  453.         if (spval > lineno && lineno == 0)
  454.             phead();
  455.         if (spval > lineno)
  456.             space(spval - lineno);
  457.         break;
  458.     case RESET:    /****/
  459.         finit();
  460.         break;
  461.     default:
  462.         error("? Botch in command.");
  463.         break;
  464.     }
  465. }
  466.  
  467. /*
  468.  * comtype - decode the command type
  469.  *
  470.  */
  471. int
  472. comtype(buf, siz, defn, flags)
  473. char buf[];
  474. int siz;
  475. char **defn;
  476. int *flags;
  477. {
  478.  
  479.     struct hashlist *np;
  480.     struct lexlist *xp;
  481.     extern    struct lexlist *lexlook();
  482.     int i,comtyp;
  483.     char c1,c2;
  484.  
  485.  
  486. #ifdef DEBUG
  487.     printf("comtype:  (token)\n");
  488. #endif
  489.  
  490.     if ((np = lookup(buf, macrotab)) != NULL) {
  491.         *defn=np->def;
  492.         return(MACRO);
  493.     }
  494.     comtyp = UNKNOWN;
  495.  
  496.     if (*buf == '#' || *buf == '!')
  497.         return(comtyp);
  498.  
  499.     if ((xp = lexlook(buf,lextab)) != NULL)
  500.         if (onlyrunoff && (xp->flag != RUNOFF)) {
  501.             fprintf(stderr,"%c%s is not a runoff command.\n",
  502.             cchar,buf);
  503.             return(UNKNOWN);
  504.         }
  505.         else {    
  506.             comtyp = xp->val;
  507.             *flags = xp->flag;
  508.         }
  509.  
  510.     if (comtyp == UNKNOWN)
  511.         fprintf(stderr,"unknown command %c%s\n",cchar,buf);
  512.     return(comtyp);
  513. }
  514.